import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

// 这是一个测试程序

/**
 * 文档注释：
 *
 * @author will
 * 作用Test类，入门第一个程序练习
 * @version v1.0.0
 */
public class Test {


    public static void main(String[] args) {
//        int a = 10;
//        int b = 20;
//        double c = a > b? 1 : 2.0;
//        System.out.println(c); //2.0

//        int a = 10;
//        int b = 20;
//        a > b? a : b; // 报错：Error:(23:14) java: 不是语句




//        boolean flg = true == true ? false ? true : false : true;
//        System.out.println(flg); //false


        // 求a和b的平均值
        int a = 10;
        int b = 20;
        int c = a + (b - a) >> 1;
        System.out.println(c);




    }


    public static void main12(String[] args) {
//        int a = 10;
//        int b = 20;
//
//        //按位与 &
//        System.out.println(a & b); // 0
//
//        //按位或 |
//        System.out.println(a | b); // 30

//        // 按位取反 ~
//        int a = 0xf;
//        System.out.printf("%x\n", ~a); //0xfffffff0


//        // 按位异或^
//        int a = 0x1;
//        int b = 0x2;
//        System.out.printf("%x\n", a ^ b); //0x3
    }


    public static void main11(String[] args) {
//        int a = 1;
//        int b = 2;
//        System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
//        System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
//        System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
//        System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假


//        int a = 1;
//        int b = 2;
//        System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
//        System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
//        System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
//        System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

//        int a = 1;
//        System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
//        System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

        System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
        System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

    }

    public static void main10(String[] args) {
        //int a = 20;
        //int b = 10;

//        System.out.println(a + b); // 30
//        System.out.println(a - b); // 10
//        System.out.println(a * b); // 200
//        System.out.println(a / b); // 2
//        System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数


        int a = 3;
        int b = 2;

        // 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
        System.out.println(a / b); // 1

        // 如果要得到数学中的结果，可以使用如下方式
        double d = a * 1.0 / b;
        System.out.println(d); // 1.5

        System.out.println(1 + 0.2); // +的左侧是int，右侧是double，在加之前int被提升为double
        // 故：输出1.2

        //System.out.println(3 < a < 5);


    }


    public static void main9(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a = " + a + " b = " + b); //字符串 拼接 其他 = 字符串
        System.out.println(a + b);

        System.out.println("a + b = " + a + b); //整体仍是字符串
        System.out.println(a + b + "a + b");// 先加后拼接
    }

    public static void main8(String[] args) {

        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由小到大，隐式转换
        a = (int) b; // long-->int, 数据范围由大到小，需要强转，否则编译失败

        float f = 3.14F;
        double d = 5.12;
        d = f; // float-->double，数据范围由小到大，隐式转换
        f = (float) d; // double-->float, 数据范围由大到小，需要强转，否则编译失败

        //a = d; // 报错，类型不兼容
        a = (int) d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃

        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte) 257; // 257默认为int，超过byte范围，需要显示转换，否则报错

        boolean flag = true;
        //a = flag; // 编译失败：类型不兼容
        //flag = a; // 编译失败：类型不兼容
    }

    public static void main7(String[] args) {

        int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
        double d = 3.14;
        char c = 'A';
        boolean b = true;

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);


        a = 100; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
        System.out.println(a);

        // 注意：在一行可以定义多个相同类型的变量
        int a1 = 10, a2 = 20, a3 = 30;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);

    }

    public static void main5(String[] args) {
        /*System.out.println("hello world!");
        System.out.println(100);
        System.out.println(12.5);
        System.out.println('A');
        System.out.println(true);
        System.out.println(false);*/

        /*final int a = 10;
        a = 20; // 编译出错，提示 无法为最终变量a分配值
        System.out.println(a);*/
    }




    /*
    多行注释：
    1. main方法是Java程序的入口方法
    2. main函数的格式是固定的，必须为public static void main(String[] args)
    */

    /**
     * main方法是程序的入口函数
     *
     * @param args 命令行参数。
     */
    public static void main4(String[] args) {
        // 单行注释：System.out.println是Java中标准输出，会将内容输出到控制台
        System.out.println("HelloWorld");
    }


    public static void main6(String[] args) {
        int a = 100;
        long l = 10L;
        a = (int) l; // 强制类型转换，(int)相当于盖了章给了承诺

        short s = 10;
        s = (short) (s + 9);
        System.out.println(s); //19

        short s1 = 10;
        s1 += 9;
        System.out.println(s1); //19
    }


    public static void main3(String[] args) {
        char a = 'a';
        char b = '杨';
        System.out.println(a);
        System.out.println(b);

        boolean flg = true;
        System.out.println(flg);


    }

    public static void mainDouble(String[] args) {

        double d = 12.5;
        System.out.println(d);

        /*double a = 1;
        double b = 2;
        System.out.println(a / b);// 0*/

        double a = 1.0;
        double b = 2;
        System.out.println(a / b);// 0.5

        int c = 1;
        int e = 2;
        System.out.println(c * 1.0 / e);// 0.5

        double num = 1.1;
        System.out.println(num * num); //
        //认为应该是1.21，运行结果为1.2100000000000002
        //表明小数 并没有一个非常精确的数字，而是精确到小数点后几位
        // 浮点型只能精确到小数点后六位，后面的不能保证是精确的


        //float f = 12.5; // 会报错，12.5默认是double类型，double类型是8个字节，float是4个字节，不能直接赋值
        // 需要在12.5后加f，大写F也行。但是在C语言中可以直接赋值。

        float f = 12.5f;
        System.out.println(a);

    }


    public static void mainShort(String[] args) {

        byte b = 20;
        System.out.println(b);
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);


        short a = 10;
        System.out.println(a);
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
    }

    public static void mainLong(String[] args) {
        /**
         * 长整型
         * 8个字节
         * 63个bit位，一个符号位
         */

        long a = 10L; //长整形数据后面一般会加上大写L，表示是长整型数据
        //也可以是小写的l，但是不建议这样写，可能会看错当作101
        System.out.println(a);
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);

    }

    public static void main2(String[] args) {
        /*int a = 10;

        // Java当中，局部变量在使用的时候，必须初始化
        int b;
        b = 19;
        System.out.println(b);*/

        int c = 2147483647;
        //int c = 2147483648; // 报错
        System.out.println(c);
        c = 100;
        System.out.println(c);

        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);


    }


    /**
     * 这是一个main方法
     *
     * @param args 可以描述它是干什么的
     */
    public static void main1(String[] args) {
        System.out.println("nihao,jiayou!");
        /*//输出不需要再格式化
        System.out.println(10);
        System.out.println(10.5);
        System.out.println(true);*/
        // ctr + d 多一行  ctr + x 剪切   ctr + z 撤销

        int $a = 10;
        System.out.println($a);

        int a = 10;

        // int int = 10; 这样定义标识符不规范

        // main 可以定义标识符但是合法不合理
        int main = 10;

    }
}
